#include <iostream>
using namespace std;

namespace 电脑
{
    // class 芯片;
    // class 显卡;
    // class 内存;

    class 芯片
    {
    private:
        /* data */
    public:
        芯片(/* args */);
        virtual void calculate () = 0;
        virtual ~芯片() = 0;
    };

    芯片::芯片(/* args */)
    {
    }

    芯片::~芯片()
    {
    }

    /* ------------------------------------------------------ */
    class 显卡
    {
    private:
        /* data */
    public:
        显卡(/* args */);
        virtual void display () = 0;
        virtual ~显卡() = 0;
    };

    显卡::显卡(/* args */)
    {
    }

    显卡::~显卡()
    {
    }

    /* ------------------------------------------------------ */
    class 内存
    {
    private:
        /* data */
    public:
        内存(/* args */);
        virtual void storage () = 0;
        virtual ~内存() = 0;
    };

    内存::内存(/* args */)
    {
    }

    内存::~内存()
    {
    }


    /* =================================================== */
    class AbstractComputer
    {
    private:
        芯片    * m_cpu;
        显卡    * m_gpu;
        内存    * m_ddr;
    public:
        AbstractComputer(芯片 * cpu, 显卡 * gpu, 内存 * ddr);
        // 提供工作函数
        void work ()
        {
            m_cpu->calculate();
            m_gpu->display();
            m_ddr->storage();
        }
        ~AbstractComputer();
    };

    AbstractComputer::AbstractComputer(芯片 * cpu, 显卡 * gpu, 内存 * ddr)
    {
        m_cpu = cpu;
        m_gpu = gpu;
        m_ddr = ddr;
    }
    /* =================================================== */
    AbstractComputer::~AbstractComputer()
    {
        if (m_cpu != nullptr) {
            delete m_cpu;
            m_cpu = nullptr;
        }

        if (m_gpu != nullptr) {
            delete m_gpu;
            m_gpu = nullptr;
        }

        if (m_ddr != nullptr) {
            delete m_ddr;
            m_ddr = nullptr;
        }
    }
/* =============================================== */
    // 具体供应商
    // Intel厂商
    class Intel芯片 : public 芯片
    {
    private:
        /* data */
    public:
        Intel芯片(/* args */);
        virtual void calculate () 
        {
            cout << "Intel 的芯片开始计算了！" << endl;
        }
        ~Intel芯片();
    };

    Intel芯片::Intel芯片(/* args */)
    {
    }

    Intel芯片::~Intel芯片()
    {
    }
    /* ------------------------------------------------------ */
    // Intel厂商
    class Intel显卡 : public 显卡
    {
    private:
        /* data */
    public:
        Intel显卡(/* args */);
        virtual void display () 
        {
            cout << "Intel 的显卡开始显示了！" << endl;
        }
        ~Intel显卡();
    };

    Intel显卡::Intel显卡(/* args */)
    {
    }

    Intel显卡::~Intel显卡()
    {
    }
    /* ------------------------------------------------------ */

    class Intel内存 : public 内存
    {
    private:
        /* data */
    public:
        Intel内存(/* args */);
        virtual void storage () 
        {
            cout << "Intel 的内存开始存储了！" << endl;
        }
        ~Intel内存();
    };

    Intel内存::Intel内存(/* args */)
    {
    }

    Intel内存::~Intel内存()
    {
    }
/* ============================================================== */
    // Lenovo厂商
    class Lenovo芯片 : public 芯片
    {
    private:
        /* data */
    public:
        Lenovo芯片(/* args */);
        virtual void calculate () 
        {
            cout << "Lenovo 的芯片开始计算了！" << endl;
        }
        ~Lenovo芯片();
    };

    Lenovo芯片::Lenovo芯片(/* args */)
    {
    }

    Lenovo芯片::~Lenovo芯片()
    {
    }
    /* ------------------------------------------------------ */
    // Lenovo厂商
    class Lenovo显卡 : public 显卡
    {
    private:
        /* data */
    public:
        Lenovo显卡(/* args */);
        virtual void display () 
        {
            cout << "Lenovo 的显卡开始显示了！" << endl;
        }
        ~Lenovo显卡();
    };

    Lenovo显卡::Lenovo显卡(/* args */)
    {
    }

    Lenovo显卡::~Lenovo显卡()
    {
    }

    /* ------------------------------------------------------ */
    class Lenovo内存 : public 内存
    {
    private:
        /* data */
    public:
        Lenovo内存(/* args */);
        virtual void storage () 
        {
            cout << "Lenovo 的内存开始存储了！" << endl;
        }
        ~Lenovo内存();
    };

    Lenovo内存::Lenovo内存(/* args */)
    {
    }

    Lenovo内存::~Lenovo内存()
    {
    }

} // namespace 电脑


void test01()
{
    // 第一台电脑的零件
    电脑::芯片 * intelCpu = new 电脑::Intel芯片;
    电脑::显卡 * intelCard= new 电脑::Intel显卡;
    电脑::内存 * intelddr = new 电脑::Intel内存;

    电脑::AbstractComputer * computer1 = new 电脑::AbstractComputer(intelCpu, intelCard, intelddr);
    cout << "第一台电脑开始工作！" << endl;
    cout << "-----------------" << endl;
    computer1->work();
    cout << "-----------------" << endl;
    delete computer1;

    电脑::AbstractComputer * computer2 = new 电脑::AbstractComputer(new 电脑::Lenovo芯片, new 电脑::Lenovo显卡, new 电脑::Intel内存);
    cout << "第二台电脑开始工作！" << endl;
    cout << "-----------------" << endl;
    computer2->work();
    cout << "-----------------" << endl;
    delete computer2;
}


int main()
{
    test01();
    return 0;
}